main_freertos_single_task.c

Go to the documentation of this file.

/*
 * Copyright (c) 2016, NXP Semiconductor, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * o Redistributions of source code must retain the above copyright notice, this list
 *   of conditions and the following disclaimer.
 *
 * o Redistributions in binary form must reproduce the above copyright notice, this
 *   list of conditions and the following disclaimer in the documentation and/or
 *   other materials provided with the distribution.
 *
 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*! \file main_freertos_single_task.c
    \brief FreeRTOS (single task) implementation of sensor fusion on FRDM-K64F.

    This file shows one recommended way to incorporate sensor fusion capabilities
    into a FreeRTOS project.
*/

/* FreeRTOS kernel includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "timers.h"
#include "event_groups.h"

// ISSDK Headers
#include "fxls8471q.h"
#include "mag3110.h"
#include "fxas21002.h"
#include "mpl3115.h"
#include "mma865x.h"
#include "fxos8700.h"
#include "mma9553.h"

// KSDK Headers
#include "fsl_debug_console.h"  // KSDK header file for the debug interface
#include "board.h"              // KSDK header file to define board configuration
#include "pin_mux.h"            // KSDK header file for pin mux initialization functions
#include "clock_config.h"       // KSDK header file for clock configuration
#include "fsl_port.h"           // KSDK header file for Port I/O control
#include "fsl_i2c.h"            // KSDK header file for I2C interfaces

// Sensor Fusion Headers
#include "sensor_fusion.h"      // top level magCal and sensor fusion interfaces
#include "hal.h"                // Hardware Abstraction Layer board dependencies beyond those generated in board.h by PEX
#include "control.h"            // Command/Streaming interface - application specific
#include "status.h"             // Status indicator interface - application specific
#include "drivers.h"            // NXP sensor drivers OR customer-supplied drivers
#include "driver_pit.h"         // Project-specific - PIT is used to control main() timing loop

// Global data structures
SensorFusionGlobals sfg;                ///< This is the primary sensor fusion data structure
ControlSubsystem controlSubsystem;      ///< used for serial communications
StatusSubsystem statusSubsystem;        ///< provides visual (usually LED) status indicator
PhysicalSensor sensors[2];              ///< This implementation uses two physical sensors
EventGroupHandle_t event_group = NULL;

// externals
extern uint8_t sUARTOutputBuffer[256];                   ///< main output buffer defined in control.c
extern ARM_DRIVER_I2C Driver_I2C1_KSDK2_Blocking;       ///< KSDK handle for the I2C port defined in Driver_I2C_KSDK2.
#define I2C_DRIVER Driver_I2C1_KSDK2_Blocking

/// Dummy callback function for the I2C driver
void myI2C_callback(uint32_t event)
{
    // Only needs to be present
}
static void read_task(void *pvParameters);

ARM_DRIVER_I2C* I2Cdrv = &I2C_DRIVER;                       ///< KSDK handle for the I2C port defined in Driver_I2C_KSDK2.c

/// This is a FreeRTOS (single task) implementation of the NXP sensor fusion demo build.
int main(void)
{
    BOARD_InitPins();                   // defined in pin_mux.c, initializes pkg pins
    BOARD_BootClockRUN();               // defined in clock_config.c, initializes clocks
    BOARD_InitDebugConsole();           // defined in board.c, initializes the OpenSDA port

    I2Cdrv->Initialize(myI2C_callback);                                 // Initialize the KSDK driver for the I2C port
    CLOCK_EnableClock(I2C_PORT_CLKEN);                                  // You must ewnable a port's clock before configuring it
    PORT_SetPinMux(I2C_PORT, I2C_SDA_PIN, I2C_MUX);                     // Configure the SDA pin muxing
    PORT_SetPinMux(I2C_PORT, I2C_SCL_PIN, I2C_MUX);                     // Configure the SCL pin muxing
    CLOCK_EnableClock(I2C_CLKEN);                                       // Enable the clock for the I2C module
    I2C_DRIVER.Control(ARM_I2C_BUS_SPEED, ARM_I2C_BUS_SPEED_FAST);      // Configure the I2C bus speed

    initializeControlPort(&controlSubsystem);                           // configure pins and ports for the control sub-system
    initializeStatusSubsystem(&statusSubsystem);                        // configure pins and ports for the status sub-system
    initSensorFusionGlobals(&sfg, &statusSubsystem, &controlSubsystem); // Initialize sensor fusion structures
    // "install" the sensors we will be using
    sfg.installSensor(&sfg, &sensors[0], F_ALL_SENSORS, 0x1E, 1, (void*) I2Cdrv, FXOS8700_Init,  FXOS8700_Read);
    sfg.installSensor(&sfg, &sensors[1], F_ALL_SENSORS, 0x20, 1, (void*) I2Cdrv, FXAS21002_Init, FXAS21002_Read);
    sfg.initializeFusionEngine(&sfg);           // This will initialize sensors and magnetic calibration

    event_group = xEventGroupCreate();
    xTaskCreate(read_task, "READ_TASK", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
    sfg.setStatus(&sfg, NORMAL);                // If we got this far, let's set status state to NORMAL
    /* Start scheduling. */
    vTaskStartScheduler();
    for (;;) ;
}

static void read_task(void *pvParameters)
{
    uint16_t i=0;                       // general counter variable
    portTickType lastWakeTime;
    const portTickType frequency = 10;
    lastWakeTime = xTaskGetTickCount();
    while (1)
    {
            vTaskDelayUntil(&lastWakeTime, frequency);
            GPIO_TogglePinsOutput(GPIOB, 1U << 9U); // toggle GPIO pin to check freq - DEBUG ONLY

            sfg.readSensors(&sfg, 1);           // Reads sensors, applies HAL and does averaging (if applicable)
            sfg.runFusion(&sfg);                // Run the actual fusion algorithms
            sfg.applyPerturbation(&sfg);        // apply debug perturbation (testing only)
            sfg.loopcounter++;                  // The loop counter is used to "serialize" mag cal operations
            i=i+1;
            if (i>=4) {                         // Some status codes include a "blink" feature.  This loop
                    i=0;                        // should cycle at least four times for that to operate correctly.
                    sfg.updateStatus(&sfg);     // This is where pending status updates are made visible
            }
            sfg.queueStatus(&sfg, NORMAL);      // assume NORMAL status for next pass through the loop
            sfg.pControlSubsystem->stream(&sfg, sUARTOutputBuffer);      // Send stream data to the Sensor Fusion Toolbox
    }
}

/// \endcode